MIT 6.031：Software Constructtion

MIT 6.031：Software Constructtion

01：Static Checking

冰雹序列：冰雹在云中通过上下弹跳而成，直到他们最终积聚重量最后落下。
Python代码：

  
n=3  
while n!=1:  
    print(n)  
    if n%2 ==0:  
        n=n/2  
  else:  
        n=3*n+1  
print(n)

Java代码：

package com.company;  
  
public class Main {  
  
    public static void main(String[] args) {  
   // Java  
  int n=3;  
 while(n!=1){  
            System.out.println(n);  
 if(n%2==0){  
                n=n/2;  
  }else{  
                n=3*n+1;  
  }  
        }  
        System.out.println(n);  
  }  
}

静态检查、动态检查、不检查

• 静态检查：主要是语法上的检查，比如类型错误，内存溢出，拼写错误等，在代码执行前检查。
• 动态检查：针对于某个特定值的检查，比如零除，代码执行时检查。
• 不检查：代码不报错，但是返回的是错误值，比如整数相除，5/2不返回0.2，而是0。

数组和集合

package com.company;  
  
public class ArrayHailstone {  
    public static void main(String[] args) {  
        int[] a = new int[100];  
 int i = 0;  
 int n = 3;  
 while (n != 1) {  
            System.out.println(n);  
  a[i]=n;  
  i++;  
 if(n%2==0){  
                n=n/2;  
  }else{  
                n=3*n+1;  
  }  
        }  
        a[i]=n;  
  i++;  
  System.out.println(n);  
  }  
}

数组最明显的问题是会发生内存溢出，所以用列表比较合理。

package com.company;  
  
import java.util.ArrayList;  
import java.util.List;  
  
public class ListHailstone {  
    public static void main(String[] args){  
        List<Integer> list=new ArrayList<Integer>();  
 int n=3;  
 while(n!=1){  
            list.add(n);  
 if(n%2==0){  
                n=n/2;  
  }else{  
                n=3*n+1;  
  }  
        }  
        list.add(n);  
  System.out.print(list);  
  }  
}

数组和列表的区别是:列表是接口，不能直接构造的类型，list提供get、set、add等操作，写在等号右边。数组是类，可以提供这些操作具体实现的类型。从上面两段代码也能发现，数组不需要引入包，列表需要。

方法

package com.company;  
  
import java.util.ArrayList;  
import java.util.List;  
  
public class Hailstone {  
    public static List<Integer> hailstoneSequence(int n){  
        List<Integer> list=new ArrayList<Integer>();  
 while(n!=1){  
            list.add(n);  
 if(n%2==0){  
                n=n/2;  
  }else{  
                n=3*n+1;  
  }  
        }  
        return list;  
  }  
}

02：Basic Java

改变值与重新分配变量

重新分配和不可变值

String值一旦被创建，永远不会改变。

可变值

StringBuilder可变。

StringBuilder Sb =new;
StringBuilder("a");
sb.append("b");

不可重新分配的引用

变量被分配一次，不可再重新分配。

final int =n;

对可变值进行不可重新分配的引用

final StringBuilder sb=new StringBuilder("a");
sb.append(”b");

可重新分配的参考到一个不可变的值。

String s="a";
s="ab";

关于<>和等于

class A():
 def __init__(self, v): 
  self.value = v
 def __eq__(self, t): 
  return self.value == t.value
a = A(3)
b = A(3)
print(a == b)
print(a is b)

python中==比较值，is比较是否是同一个对象

Java中==比较原始值，如char、int、double，x.equals()比较对象的值，如列表、数组、字符串和其他对象。

Written by luyao 20230428.